package sanrenxing.reexams.servlet;

import com.google.gson.Gson;
import com.google.gson.JsonSyntaxException;
import sanrenxing.course.domain.CourseName;
import sanrenxing.reexams.dao.ReexamsDao;
import sanrenxing.reexams.dao.impl.ReexamsDaoImpl;
import sanrenxing.reexams.domain.PaperAdd;
import sanrenxing.reexams.domain.PaperId;
import sanrenxing.reexams.domain.Reexams;
import sanrenxing.reexams.domain.ReexamsTo;

import javax.servlet.ServletException;
import javax.servlet.annotation.WebServlet;
import javax.servlet.http.HttpServlet;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import java.io.IOException;
import java.io.PrintWriter;
import java.util.HashMap;
import java.util.List;
import java.util.Map;

/**
 * @description：对reexams表操作的控制器类
 * @auth：阳赛
 * @date:2020/8/26 0026 - 9:58
 * @version:1.0
 */
@WebServlet("/ReexamsServlet")
public class ReexamsServlet extends HttpServlet {
    //定义数据层对象reexamsDao
    private ReexamsDao reexamsDao=new ReexamsDaoImpl();

    @Override
    protected void doGet(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
        req.setCharacterEncoding("utf-8");
        resp.setContentType("text/html");
        resp.setCharacterEncoding("utf-8");

        //获得请求路径method中的操作方式参数
        String method=req.getParameter("method");
        //判断操作方式，执行方法代码
        if("findAll".equals(method)){
            //调用查询所有数据的方法
            findAll(req,resp);
        }else if("add".equals(method)){
            //调用增加补考的方法
            add(req,resp);
        }else if("update".equals(method)){
            //调用修改方法
            update(req,resp);
        }else if("batchDel".equals(method)){
            //调用删除方法
            batchDel(req,resp);
        }else if("delete".equals(method)){
            //删除单行
            delete(req,resp);
        }else if ("findPaperId".equals(method)){
            //查询所有试卷编号findPaperId
            findPaperId(req,resp);
        }
    }

    private void findPaperId(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
        //定义输出流对象
        PrintWriter out=resp.getWriter();
        //调用方法获取班级名称
        List<PaperId> paperIdList=reexamsDao.findPaperId();
        //Map字符串和对象 ma等于一个新的HashMap<>对象（）
        Map<String,Object> map=new HashMap<>();
        //p将paperIdList对象集合放入map.put对象中，并命名为“json1”
        map.put("json1",paperIdList);
        //创建一个Gson对象
        Gson gson=new Gson();
        //定义一个String字符串json1等于g点tJ（map）;
        String json1=gson.toJson(map);
        //json1不等于”空“
        if (json1!=""){
            //json1
            out.print(json1);
        }else{
            //“no”
            out.print("no");
        }
    }

    /**
     * 批量删除数据
     * @param req 请求对象
     * @param resp 响应对象
     * @throws ServletException Servlet异常
     * @throws IOException IO异常
     */
    private void batchDel(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
        //定义输出流对象
        PrintWriter out=resp.getWriter();

        //得到来自请求中的补考编号字符串reexamsIdStr'
        String reexamsIdStr=req.getParameter("reexamsNoStr");
        //S[对补考编号字符串reexamsIdStr按","进行分割rIS.st
        String[] reexamsIdStrs=reexamsIdStr.split(",");
        //由于是批量删除，使用异常和循环来进行判断删除是否成功
        try{
            //S循环删除 rS:rS
            for(String reexamsStr:reexamsIdStrs){
                //把字符串转换为整型的补考编号reexamsNo,rS
                int reexamsNo=Integer.parseInt(reexamsStr);
                //调用数据层代码进行删除reexamsNo
                reexamsDao.delete(reexamsNo);
            }
            //向客户端发送操作结果
            //ok
            out.print("ok");
        }catch(Exception e){
            //no
            out.print("no");
        }
        //关闭输出流对象
        out.close();
    }

    /**
     * 删除数据
     * @param req 请求对象
     * @param resp 响应对象
     * @throws ServletException Servlet异常
     * @throws IOException IO异常
     */
    private void delete(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
        //定义输出流对象out
        PrintWriter out=resp.getWriter();
        //得到来自请求中的补考编号字符串reexamsIdStr
        String reexamsIdStr=req.getParameter("reexamsId");
        //获取试卷编号paperId
        int paperId= Integer.parseInt(req.getParameter("paperId"));
        //获取学员姓名stuName
        String stuName=req.getParameter("stuName");
        //调用数据层方法通过学员名称stuName查询学员编号stuId
        String stuId=reexamsDao.findStuId(stuName);
        //调用数据层方法通过学员名称stuName查询班级编号classId
        int classId=reexamsDao.findClassId(stuName);
        //创建实体类对象PaperAdd 把接收到的学生编号，班级编号，试卷编号，"待考试"保存
        PaperAdd paperAdd=new PaperAdd(stuId,classId,paperId,"待考试");
        try{
            //把字符串转换为整型的补考编号reexamsId
            int reexamsId=Integer.parseInt(reexamsIdStr);
            //调用数据层代码进行delete删除reexamsId
            reexamsDao.delete(reexamsId);
            //调用数据层进行addStatu添加paperAdd
            reexamsDao.addStatu(paperAdd);
            //向客户端发送操作结果
            //ok
            out.print("ok");
        }catch(Exception e){
            //no
            out.print("no");
        }
        //关闭out输出流对象
        out.close();
    }

    /**
     * 修改reexams表中的补考数据
     * @param req 请求对象
     * @param resp 响应对象
     * @throws ServletException Servlet异常
     * @throws IOException IO异常
     */
    private void update(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException{
        //定义输出对象
        PrintWriter out=resp.getWriter();
        //接收来自前端请求的json数据字符串
        String json=req.getParameter("json");
        //定义Gson操作对象
        Gson gson = new Gson();
        //通过gson对象将json数据转换成补考对象
        //定义Reexams r为空
        Reexams reexams= null;
        try {
            //将reexams 赋值gson 调用fromJson，传json,补考class类参
            reexams = gson.fromJson(json, Reexams.class);
        } catch (JsonSyntaxException e) {
            //e.pT
            e.printStackTrace();
        }
        //调用数据层方法rows，实现update数据添加reexams
        int rows=reexamsDao.update(reexams);
        //判断操作是否成功
        if(rows>0){
            //ok
            out.print("ok");
        }else{
            //no
            out.print("no");
        }
        //关闭输出流对象
        out.close();
    }

    private void add(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException{
        //定义输出对象
        PrintWriter out=resp.getWriter();
        //接收来自前端请求的json数据字符串
        String json=req.getParameter("json");
        //定义Gson操作对象
        Gson gson = new Gson();
        //通过gson对象将json数据转换成补考对象
        //定义Reexams r为空
        Reexams reexams= null;
        try {
            //将reexams 赋值gson.调用fromJson，传json,补考class类参
            reexams = gson.fromJson(json, Reexams.class);
        } catch (JsonSyntaxException e) {
            //e.pT
            e.printStackTrace();
        }
        //调用数据层方法rows，实现add数据添加reexams
        int rows=reexamsDao.add(reexams);
        //判断操作是否成功
        if(rows>0){
            //ok
            out.print("ok");
        }else{
            //no
            out.print("no");
        }
        //关闭输出流对象out
        out.close();
    }

    /**
     *
     * @param req
     * @param resp
     * @throws ServletException
     * @throws IOException
     */
    private void findAll(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException{
        //创建输出流对象
        PrintWriter out=resp.getWriter();
        //获取当前页数pageStr (page)
        String pageStr = req.getParameter("page");
        //定义页数page为1
        int page = 1;
        //pageStr不为空，且pageStr.调用trim.length不为0
        if(pageStr!=null && pageStr.trim().length()!=0){
            //将page 强制转换为int类型
            page = Integer.parseInt(pageStr);
        }
        //rowsStr获取每页行数limit
        String rowsStr = req.getParameter("limit");
        //定义行数为5
        int rows = 5;
        //rowsStr不为空，且rowsStr.调用trim.length不为0
        if(rowsStr!=null && rowsStr.trim().length()!=0){
            //将rows强制转换为int类型
            rows = Integer.parseInt(rowsStr);
        }
        //定义用于构造多条件查询的补考对象
        Reexams reexams= new Reexams();
//        //获取来自请求中的reexamsId补考编号
//        String reexamsId=req.getParameter("reexamsId");
//        //判断补考编号，是否加入到补考对象中
//        if(reexamsId!=null && reexamsId.trim().length()!=0){
//            reexams.setReexamsId(Integer.parseInt(reexamsId));
//        }
        //获取来自请求中的补考姓名stuName
        String stuName=req.getParameter("stuName");
        //判断并加入到补考对象中
        //stuName不为空，且stuName.调用trim.length不为0
        if(stuName!=null && stuName.trim().length()!=0){
            //调用数据库代码，通过学员姓名stuName查询学员编号stuId
            String stuId=reexamsDao.findStuId(stuName);
            //通过补考表reexams查询学生编号stuId
            reexams.setStuId(stuId);
        }
        //获取来自请求的部门编号courseName
        String courseName=req.getParameter("courseName");
        //判断并加入
        //courseName不为空，且courseName.调用trim.length不为0
        if(courseName!=null && courseName.trim().length()!=0){
            //调用数据库代码，通过课程姓名stuNacourseId查询课程编号courseId
            int courseId=reexamsDao.findCourseId(courseName);
            //通过补考表reexams查询课程编号courseId
            reexams.setCourseId(courseId);
        }
        //调用数据层方法，根据员工对象condition构造查询条件字符串reexams
        String condition=reexamsDao.getCondition(reexams);
        //调用数据层方法，创建一个List<reexamsToList>集合，执行多条件分页findByPage查询rows,page,condition
        List<ReexamsTo> reexamsToList=reexamsDao.findByPage(rows,page,condition);
        //调用数据层方法，多条件查询totalRows表中总记录数count(condition)
        int totalRows=reexamsDao.count(condition);

        //定义映射集合对象 M<S,O> mapData等于新的HashMap<S,O>（）
        Map<String,Object> mapData=new HashMap<String,Object>();
        //在映射集合mapData中put添加key为code，值为0的状态码
        mapData.put("code",0);
        //在映射集合mapData中put添加key为msg,值为响应信息字符串“空”
        mapData.put("msg","");
        //在映射集合mapData中put添加key为count,值总行数的数据对totalRows
        mapData.put("count",totalRows);
        //在映射集合mapData中put添加key为data,值为集合对象reexamsToList
        mapData.put("data",reexamsToList);
        //新建Gson对象
        Gson gson=new Gson();
        //S使用Gson对象把映射集合转换为json格式数据1 S j1=g.tJ(mapData)
        String json1=gson.toJson(mapData);
        //将json1数据输出到客户端write
        out.write(json1);
        //关闭输出流对象
        out.close();
    }
    @Override
    protected void doPost(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
        this.doGet(req, resp);
    }
}
